python面向对象（一）

发表于 | 更新于 | 分类于

类的构建、使用与识别

类的构建

  • 类的基本构建

    1
    2
    3
    class 类名(父类名)：
    	“类描述，文档字符串 可选”
        语句块

    1. 类定义不限位置，可以包含在分支或其他从属语句块中，执行时存在即可。

    2. 类名：可以是任何有效标识符，建议采用大写单词的组合。如ClassName

    3. 类描述：在类定义后首行，以独立字符串形式定义。定义后通过<类名>.__doc__属性来访问

    4. 定义好的类在解释器读取完代码后自动生成一个类对象，每个类唯一对应一个类对象，用于存储这个类的基本信息。类对象是type类的实例，表达为type类型。

    5. 类对象内直接包含的语句会被执行，因此一般不在类定义中直接包含语句

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # 一个极度简单的类
    class Person(object):
        "this is a class for person"
        print('我是类中直接定义的print语句')

    print(Person.__doc__)
    print(type(Person))

    d = Person()
    print(type(d))

    '''输出结果
    我是类中直接定义的print语句
    this is a class for person
    <class 'type'>
    <class '__main__.Person'>
    '''

  • 类的属性和方法

    属性和方法是类对外交互所提供的两种接口方式

    1. 属性：类中定义的变量，用来描述类的一些特性参数。分为类属性和实例属性。

      类属性是类对象的属性，由所有实例对象所共享。类名.类属性 或 对象名.类属性

      实例属性是实例对象的属性，由各实例对象独享。对象名.实例属性

      1
      2
      3
      4
      5
      6
      7
      # 基本模式
      class 类名(父类名):
          类属性名 = 类属性初值
          def 方法名(self,参数):
              语句块
              self.实例属性名 = 实例属性处置
      		语句块
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      # 简单实例
      class Person(object):
          count = 0
          def add(self, name):
              # 新建实例对象时count自增这个需求更适合在构造方法中实现，这里只是举例说明实例属性和类属性
              self.name = name
              print('添加一人', self.name)
              Person.count += 1

      p1 = Person()
      p1.add('老王')
      print('当前人数：',Person.count)

      p2 = Person()
      p2.add('老张')
      print('当前人数：',Person.count)

      '''输出结果
      添加一人 老王
      当前人数： 1
      添加一人 老张
      当前人数： 2
      '''

      self是python面向对象中约定的一个类参数，代表类的实例。在类内部，self用于组合访问实例相关的属性和方法。

      相比，类名代表类对象本身

    2. 方法：类内部定义的函数，用来给出类的操作功能。分为5种：

      • 类方法：类对象的方法，由类对象或实例对象调用，只能操作类对象和其他方法，不能操作实例属性和实例方法。
      • 实例方法：实例对象的方法，由实例对象调用，最常用。
      • 自由方法：类中的一个普通函数，只能由类对象调用
      • 静态方法：类中的一个普通函数，可以由类对象或实例对象调用
      • 保留方法/魔法方法：方法名由双下划线开始和结束，用以实现python语言预定的功能，如__len__()。可以看作规定了名字的实例方法。通过重写保留方法，可以使类符合某种约定的特性
      • 属性方法：对外表现为属性，对内表现为方法。可以用来约束对有特殊要求的属性的赋值
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      # 基本模式
      class 类名(父类名):
          def 实例方法(self, 参数列表):
              语句块

          @classmethod
      	def 类方法(cls, 参数列表):
              # cls必须是第一个参数，表示类对象本身
              # classmethod是装饰器，必须写
              # 不能使用实例方法和实例属性
              语句块

          def 自由方法(参数列表):
              # 不需要self或cls
              # 只能操作类属性和类方法
              语句块

          @staticmethod
          def 静态方法(参数列表):
              # 不需要self或cls
              # @staticmethod是装饰器，必须写
              # 不能操作实例属性和实例方法
              语句块

          def 保留方法(self, 参数列表):
              语句块

      	@property
          def 属性方法(self)：
          	return self.实例变量名
          @属性方法.setter
          def 属性方法(self, value)：
          	语句块


      对象名 = 类名(参数)

      对象名.实例方法(参数列表)

      类名.类方法(参数列表)
      对象名.类方法(参数列表)

      类名.自由方法(参数列表)

      类名.静态方法(参数列表)
      对象名.静态方法(参数列表)

      对象名.保留方法(参数列表)
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      # 关于类中不同类型方法的示例代码
      class Person(object):
          count = 0

          def __init__(self, name):
              # 这是一个保留方法
              self.name = name
              Person.count += 1

          def get_name(self):
              # 这是一个实例方法
              return self.name

          @classmethod
          def how_many(cls):
              # 这是一个类方法
              print('现在有%d个Person对象'%Person.count)
              Person.count *= 10
              print('十倍后是：%d个Person对象'%Person.count)

          def say_hi():
              # 这是一个自由方法
              print('%d个Person向你说hi'%Person.count)

          @staticmethod
          def stk_say_hi():
              # 这是一个静态方法
              print('%d个Person向你说hi'%Person.count)

          def __len__(self):
              # 这是一个保留方法
              return len(self.name)


      p1 = Person('老王')
      p2 = Person('老张')

      # 调用实例方法
      print(p1.get_name())
      print(p2.get_name())

      # 调用类方法
      p1.how_many()
      Person.how_many()

      # 调用自由方法
      Person.say_hi()

      # 调用静态方法
      Person.stk_say_hi()
      p2.stk_say_hi()

      # 调用保留方法
      print(len(p1))


      '''输出结果
      老王
      老张
      现在有2个Person对象
      十倍后是：20个Person对象
      现在有20个Person对象
      十倍后是：200个Person对象
      200个Person向你说hi
      200个Person向你说hi
      200个Person向你说hi
      2
      '''

  • 类的构造方法（使用频率最高的保留方法）

    1. 用于从类创建实例对象的过程

    2. 为实例对象创建提供了参数输入方式

    3. 为实例属性的定义和赋值提供了支持

    1
    2
    3
    4
    # python使用预定义的__init__()作为构造方法
    class 类名(父类名):
        def __init__(self, 参数列表):
            语句块

    构造方法的第一个参数约定是self，表示正在构造的实例对象自身，其他参数是实例参数

    构造函数没有返回值，或返回None，否则产生TypeError异常。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    # 简单例子
    class Person(object):
        count = 0
        def __init__(self, name):
            self.name = name
            print('正在创建一个Person类的对象，这个人的名字是',self.name)
            Person.count += 1
            print('当前已经创建了%d个Person对象'%Person.count)

    p1 = Person('老王')
    p2 = Person('哪吒')

    '''输出结果
    正在创建一个Person类的对象，这个人的名字是 老王
    当前已经创建了1个Person对象
    正在创建一个Person类的对象，这个人的名字是 哪吒
    当前已经创建了2个Person对象
    '''

  • 类的析构方法（保留方法，一般不需要编写）

    在真实删除实例对象时被调用，而不一定是调用del关键字时，del只是删除该对象名对内存中对象的一个引用。

    真实删除：当前对象的引用数为0 或 当期程序退出（垃圾回收）

    1
    2
    3
    4
    # python使用预定义的__del__()作为析构方法
    class 类名(父类):
        def __del__(self):
            语句块
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class Person(object):
        def __init__(self, name):
            self.name = name

        def __del__(self):
            print('bye', self.name)

    p1 = Person('老王')
    p2 = p1

    del p1
    print('xxxxx')
    del p2

    '''输出结果
    xxxxx
    bye 老王
    '''

类的使用

  • 创建实例对象使用类的功能

    对象名 = 类名（参数）

    对象名.属性名

    对象名.方法名（参数）

  • 直接使用类对象使用类的功能

对象的识别

python对象的三要素：标识、类型、值

  • 标识identity：对象一旦构建不会改变，用id获得，一般是内存地址
  • 类型type：对象的类型，用type()获得
  • 值value：分为可变mutable与不可变immutable两种
函数/保留字 描述
id(x) 返回x的标识，cpython用内存地址表示
x is y 判断x和y的标识是否相等，返回True/False，不判断值